home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / compiler / ast.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  68KB  |  1,841 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Python abstract syntax node definitions
  5.  
  6. This file is automatically generated by Tools/compiler/astgen.py
  7. '''
  8. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  9.  
  10. def flatten(seq):
  11.     l = []
  12.     for elt in seq:
  13.         t = type(elt)
  14.         if t is tuple or t is list:
  15.             for elt2 in flatten(elt):
  16.                 l.append(elt2)
  17.             
  18.         l.append(elt)
  19.     
  20.     return l
  21.  
  22.  
  23. def flatten_nodes(seq):
  24.     return _[1]
  25.  
  26. nodes = { }
  27.  
  28. class Node:
  29.     '''Abstract base class for ast nodes.'''
  30.     
  31.     def getChildren(self):
  32.         pass
  33.  
  34.     
  35.     def __iter__(self):
  36.         for n in self.getChildren():
  37.             yield n
  38.         
  39.  
  40.     
  41.     def asList(self):
  42.         return self.getChildren()
  43.  
  44.     
  45.     def getChildNodes(self):
  46.         pass
  47.  
  48.  
  49.  
  50. class EmptyNode(Node):
  51.     pass
  52.  
  53.  
  54. class Expression(Node):
  55.     nodes['expression'] = 'Expression'
  56.     
  57.     def __init__(self, node):
  58.         self.node = node
  59.  
  60.     
  61.     def getChildren(self):
  62.         return (self.node,)
  63.  
  64.     
  65.     def getChildNodes(self):
  66.         return (self.node,)
  67.  
  68.     
  69.     def __repr__(self):
  70.         return 'Expression(%s)' % repr(self.node)
  71.  
  72.  
  73.  
  74. class Add(Node):
  75.     
  76.     def __init__(self, .1, lineno = None):
  77.         (left, right) = .1
  78.         self.left = left
  79.         self.right = right
  80.         self.lineno = lineno
  81.  
  82.     
  83.     def getChildren(self):
  84.         return (self.left, self.right)
  85.  
  86.     
  87.     def getChildNodes(self):
  88.         return (self.left, self.right)
  89.  
  90.     
  91.     def __repr__(self):
  92.         return 'Add((%s, %s))' % (repr(self.left), repr(self.right))
  93.  
  94.  
  95.  
  96. class And(Node):
  97.     
  98.     def __init__(self, nodes, lineno = None):
  99.         self.nodes = nodes
  100.         self.lineno = lineno
  101.  
  102.     
  103.     def getChildren(self):
  104.         return tuple(flatten(self.nodes))
  105.  
  106.     
  107.     def getChildNodes(self):
  108.         nodelist = []
  109.         nodelist.extend(flatten_nodes(self.nodes))
  110.         return tuple(nodelist)
  111.  
  112.     
  113.     def __repr__(self):
  114.         return 'And(%s)' % (repr(self.nodes),)
  115.  
  116.  
  117.  
  118. class AssAttr(Node):
  119.     
  120.     def __init__(self, expr, attrname, flags, lineno = None):
  121.         self.expr = expr
  122.         self.attrname = attrname
  123.         self.flags = flags
  124.         self.lineno = lineno
  125.  
  126.     
  127.     def getChildren(self):
  128.         return (self.expr, self.attrname, self.flags)
  129.  
  130.     
  131.     def getChildNodes(self):
  132.         return (self.expr,)
  133.  
  134.     
  135.     def __repr__(self):
  136.         return 'AssAttr(%s, %s, %s)' % (repr(self.expr), repr(self.attrname), repr(self.flags))
  137.  
  138.  
  139.  
  140. class AssList(Node):
  141.     
  142.     def __init__(self, nodes, lineno = None):
  143.         self.nodes = nodes
  144.         self.lineno = lineno
  145.  
  146.     
  147.     def getChildren(self):
  148.         return tuple(flatten(self.nodes))
  149.  
  150.     
  151.     def getChildNodes(self):
  152.         nodelist = []
  153.         nodelist.extend(flatten_nodes(self.nodes))
  154.         return tuple(nodelist)
  155.  
  156.     
  157.     def __repr__(self):
  158.         return 'AssList(%s)' % (repr(self.nodes),)
  159.  
  160.  
  161.  
  162. class AssName(Node):
  163.     
  164.     def __init__(self, name, flags, lineno = None):
  165.         self.name = name
  166.         self.flags = flags
  167.         self.lineno = lineno
  168.  
  169.     
  170.     def getChildren(self):
  171.         return (self.name, self.flags)
  172.  
  173.     
  174.     def getChildNodes(self):
  175.         return ()
  176.  
  177.     
  178.     def __repr__(self):
  179.         return 'AssName(%s, %s)' % (repr(self.name), repr(self.flags))
  180.  
  181.  
  182.  
  183. class AssTuple(Node):
  184.     
  185.     def __init__(self, nodes, lineno = None):
  186.         self.nodes = nodes
  187.         self.lineno = lineno
  188.  
  189.     
  190.     def getChildren(self):
  191.         return tuple(flatten(self.nodes))
  192.  
  193.     
  194.     def getChildNodes(self):
  195.         nodelist = []
  196.         nodelist.extend(flatten_nodes(self.nodes))
  197.         return tuple(nodelist)
  198.  
  199.     
  200.     def __repr__(self):
  201.         return 'AssTuple(%s)' % (repr(self.nodes),)
  202.  
  203.  
  204.  
  205. class Assert(Node):
  206.     
  207.     def __init__(self, test, fail, lineno = None):
  208.         self.test = test
  209.         self.fail = fail
  210.         self.lineno = lineno
  211.  
  212.     
  213.     def getChildren(self):
  214.         children = []
  215.         children.append(self.test)
  216.         children.append(self.fail)
  217.         return tuple(children)
  218.  
  219.     
  220.     def getChildNodes(self):
  221.         nodelist = []
  222.         nodelist.append(self.test)
  223.         if self.fail is not None:
  224.             nodelist.append(self.fail)
  225.         
  226.         return tuple(nodelist)
  227.  
  228.     
  229.     def __repr__(self):
  230.         return 'Assert(%s, %s)' % (repr(self.test), repr(self.fail))
  231.  
  232.  
  233.  
  234. class Assign(Node):
  235.     
  236.     def __init__(self, nodes, expr, lineno = None):
  237.         self.nodes = nodes
  238.         self.expr = expr
  239.         self.lineno = lineno
  240.  
  241.     
  242.     def getChildren(self):
  243.         children = []
  244.         children.extend(flatten(self.nodes))
  245.         children.append(self.expr)
  246.         return tuple(children)
  247.  
  248.     
  249.     def getChildNodes(self):
  250.         nodelist = []
  251.         nodelist.extend(flatten_nodes(self.nodes))
  252.         nodelist.append(self.expr)
  253.         return tuple(nodelist)
  254.  
  255.     
  256.     def __repr__(self):
  257.         return 'Assign(%s, %s)' % (repr(self.nodes), repr(self.expr))
  258.  
  259.  
  260.  
  261. class AugAssign(Node):
  262.     
  263.     def __init__(self, node, op, expr, lineno = None):
  264.         self.node = node
  265.         self.op = op
  266.         self.expr = expr
  267.         self.lineno = lineno
  268.  
  269.     
  270.     def getChildren(self):
  271.         return (self.node, self.op, self.expr)
  272.  
  273.     
  274.     def getChildNodes(self):
  275.         return (self.node, self.expr)
  276.  
  277.     
  278.     def __repr__(self):
  279.         return 'AugAssign(%s, %s, %s)' % (repr(self.node), repr(self.op), repr(self.expr))
  280.  
  281.  
  282.  
  283. class Backquote(Node):
  284.     
  285.     def __init__(self, expr, lineno = None):
  286.         self.expr = expr
  287.         self.lineno = lineno
  288.  
  289.     
  290.     def getChildren(self):
  291.         return (self.expr,)
  292.  
  293.     
  294.     def getChildNodes(self):
  295.         return (self.expr,)
  296.  
  297.     
  298.     def __repr__(self):
  299.         return 'Backquote(%s)' % (repr(self.expr),)
  300.  
  301.  
  302.  
  303. class Bitand(Node):
  304.     
  305.     def __init__(self, nodes, lineno = None):
  306.         self.nodes = nodes
  307.         self.lineno = lineno
  308.  
  309.     
  310.     def getChildren(self):
  311.         return tuple(flatten(self.nodes))
  312.  
  313.     
  314.     def getChildNodes(self):
  315.         nodelist = []
  316.         nodelist.extend(flatten_nodes(self.nodes))
  317.         return tuple(nodelist)
  318.  
  319.     
  320.     def __repr__(self):
  321.         return 'Bitand(%s)' % (repr(self.nodes),)
  322.  
  323.  
  324.  
  325. class Bitor(Node):
  326.     
  327.     def __init__(self, nodes, lineno = None):
  328.         self.nodes = nodes
  329.         self.lineno = lineno
  330.  
  331.     
  332.     def getChildren(self):
  333.         return tuple(flatten(self.nodes))
  334.  
  335.     
  336.     def getChildNodes(self):
  337.         nodelist = []
  338.         nodelist.extend(flatten_nodes(self.nodes))
  339.         return tuple(nodelist)
  340.  
  341.     
  342.     def __repr__(self):
  343.         return 'Bitor(%s)' % (repr(self.nodes),)
  344.  
  345.  
  346.  
  347. class Bitxor(Node):
  348.     
  349.     def __init__(self, nodes, lineno = None):
  350.         self.nodes = nodes
  351.         self.lineno = lineno
  352.  
  353.     
  354.     def getChildren(self):
  355.         return tuple(flatten(self.nodes))
  356.  
  357.     
  358.     def getChildNodes(self):
  359.         nodelist = []
  360.         nodelist.extend(flatten_nodes(self.nodes))
  361.         return tuple(nodelist)
  362.  
  363.     
  364.     def __repr__(self):
  365.         return 'Bitxor(%s)' % (repr(self.nodes),)
  366.  
  367.  
  368.  
  369. class Break(Node):
  370.     
  371.     def __init__(self, lineno = None):
  372.         self.lineno = lineno
  373.  
  374.     
  375.     def getChildren(self):
  376.         return ()
  377.  
  378.     
  379.     def getChildNodes(self):
  380.         return ()
  381.  
  382.     
  383.     def __repr__(self):
  384.         return 'Break()'
  385.  
  386.  
  387.  
  388. class CallFunc(Node):
  389.     
  390.     def __init__(self, node, args, star_args = None, dstar_args = None, lineno = None):
  391.         self.node = node
  392.         self.args = args
  393.         self.star_args = star_args
  394.         self.dstar_args = dstar_args
  395.         self.lineno = lineno
  396.  
  397.     
  398.     def getChildren(self):
  399.         children = []
  400.         children.append(self.node)
  401.         children.extend(flatten(self.args))
  402.         children.append(self.star_args)
  403.         children.append(self.dstar_args)
  404.         return tuple(children)
  405.  
  406.     
  407.     def getChildNodes(self):
  408.         nodelist = []
  409.         nodelist.append(self.node)
  410.         nodelist.extend(flatten_nodes(self.args))
  411.         if self.star_args is not None:
  412.             nodelist.append(self.star_args)
  413.         
  414.         if self.dstar_args is not None:
  415.             nodelist.append(self.dstar_args)
  416.         
  417.         return tuple(nodelist)
  418.  
  419.     
  420.     def __repr__(self):
  421.         return 'CallFunc(%s, %s, %s, %s)' % (repr(self.node), repr(self.args), repr(self.star_args), repr(self.dstar_args))
  422.  
  423.  
  424.  
  425. class Class(Node):
  426.     
  427.     def __init__(self, name, bases, doc, code, lineno = None):
  428.         self.name = name
  429.         self.bases = bases
  430.         self.doc = doc
  431.         self.code = code
  432.         self.lineno = lineno
  433.  
  434.     
  435.     def getChildren(self):
  436.         children = []
  437.         children.append(self.name)
  438.         children.extend(flatten(self.bases))
  439.         children.append(self.doc)
  440.         children.append(self.code)
  441.         return tuple(children)
  442.  
  443.     
  444.     def getChildNodes(self):
  445.         nodelist = []
  446.         nodelist.extend(flatten_nodes(self.bases))
  447.         nodelist.append(self.code)
  448.         return tuple(nodelist)
  449.  
  450.     
  451.     def __repr__(self):
  452.         return 'Class(%s, %s, %s, %s)' % (repr(self.name), repr(self.bases), repr(self.doc), repr(self.code))
  453.  
  454.  
  455.  
  456. class Compare(Node):
  457.     
  458.     def __init__(self, expr, ops, lineno = None):
  459.         self.expr = expr
  460.         self.ops = ops
  461.         self.lineno = lineno
  462.  
  463.     
  464.     def getChildren(self):
  465.         children = []
  466.         children.append(self.expr)
  467.         children.extend(flatten(self.ops))
  468.         return tuple(children)
  469.  
  470.     
  471.     def getChildNodes(self):
  472.         nodelist = []
  473.         nodelist.append(self.expr)
  474.         nodelist.extend(flatten_nodes(self.ops))
  475.         return tuple(nodelist)
  476.  
  477.     
  478.     def __repr__(self):
  479.         return 'Compare(%s, %s)' % (repr(self.expr), repr(self.ops))
  480.  
  481.  
  482.  
  483. class Const(Node):
  484.     
  485.     def __init__(self, value, lineno = None):
  486.         self.value = value
  487.         self.lineno = lineno
  488.  
  489.     
  490.     def getChildren(self):
  491.         return (self.value,)
  492.  
  493.     
  494.     def getChildNodes(self):
  495.         return ()
  496.  
  497.     
  498.     def __repr__(self):
  499.         return 'Const(%s)' % (repr(self.value),)
  500.  
  501.  
  502.  
  503. class Continue(Node):
  504.     
  505.     def __init__(self, lineno = None):
  506.         self.lineno = lineno
  507.  
  508.     
  509.     def getChildren(self):
  510.         return ()
  511.  
  512.     
  513.     def getChildNodes(self):
  514.         return ()
  515.  
  516.     
  517.     def __repr__(self):
  518.         return 'Continue()'
  519.  
  520.  
  521.  
  522. class Decorators(Node):
  523.     
  524.     def __init__(self, nodes, lineno = None):
  525.         self.nodes = nodes
  526.         self.lineno = lineno
  527.  
  528.     
  529.     def getChildren(self):
  530.         return tuple(flatten(self.nodes))
  531.  
  532.     
  533.     def getChildNodes(self):
  534.         nodelist = []
  535.         nodelist.extend(flatten_nodes(self.nodes))
  536.         return tuple(nodelist)
  537.  
  538.     
  539.     def __repr__(self):
  540.         return 'Decorators(%s)' % (repr(self.nodes),)
  541.  
  542.  
  543.  
  544. class Dict(Node):
  545.     
  546.     def __init__(self, items, lineno = None):
  547.         self.items = items
  548.         self.lineno = lineno
  549.  
  550.     
  551.     def getChildren(self):
  552.         return tuple(flatten(self.items))
  553.  
  554.     
  555.     def getChildNodes(self):
  556.         nodelist = []
  557.         nodelist.extend(flatten_nodes(self.items))
  558.         return tuple(nodelist)
  559.  
  560.     
  561.     def __repr__(self):
  562.         return 'Dict(%s)' % (repr(self.items),)
  563.  
  564.  
  565.  
  566. class Discard(Node):
  567.     
  568.     def __init__(self, expr, lineno = None):
  569.         self.expr = expr
  570.         self.lineno = lineno
  571.  
  572.     
  573.     def getChildren(self):
  574.         return (self.expr,)
  575.  
  576.     
  577.     def getChildNodes(self):
  578.         return (self.expr,)
  579.  
  580.     
  581.     def __repr__(self):
  582.         return 'Discard(%s)' % (repr(self.expr),)
  583.  
  584.  
  585.  
  586. class Div(Node):
  587.     
  588.     def __init__(self, .1, lineno = None):
  589.         (left, right) = .1
  590.         self.left = left
  591.         self.right = right
  592.         self.lineno = lineno
  593.  
  594.     
  595.     def getChildren(self):
  596.         return (self.left, self.right)
  597.  
  598.     
  599.     def getChildNodes(self):
  600.         return (self.left, self.right)
  601.  
  602.     
  603.     def __repr__(self):
  604.         return 'Div((%s, %s))' % (repr(self.left), repr(self.right))
  605.  
  606.  
  607.  
  608. class Ellipsis(Node):
  609.     
  610.     def __init__(self, lineno = None):
  611.         self.lineno = lineno
  612.  
  613.     
  614.     def getChildren(self):
  615.         return ()
  616.  
  617.     
  618.     def getChildNodes(self):
  619.         return ()
  620.  
  621.     
  622.     def __repr__(self):
  623.         return 'Ellipsis()'
  624.  
  625.  
  626.  
  627. class Exec(Node):
  628.     
  629.     def __init__(self, expr, locals, globals, lineno = None):
  630.         self.expr = expr
  631.         self.locals = locals
  632.         self.globals = globals
  633.         self.lineno = lineno
  634.  
  635.     
  636.     def getChildren(self):
  637.         children = []
  638.         children.append(self.expr)
  639.         children.append(self.locals)
  640.         children.append(self.globals)
  641.         return tuple(children)
  642.  
  643.     
  644.     def getChildNodes(self):
  645.         nodelist = []
  646.         nodelist.append(self.expr)
  647.         if self.locals is not None:
  648.             nodelist.append(self.locals)
  649.         
  650.         if self.globals is not None:
  651.             nodelist.append(self.globals)
  652.         
  653.         return tuple(nodelist)
  654.  
  655.     
  656.     def __repr__(self):
  657.         return 'Exec(%s, %s, %s)' % (repr(self.expr), repr(self.locals), repr(self.globals))
  658.  
  659.  
  660.  
  661. class FloorDiv(Node):
  662.     
  663.     def __init__(self, .1, lineno = None):
  664.         (left, right) = .1
  665.         self.left = left
  666.         self.right = right
  667.         self.lineno = lineno
  668.  
  669.     
  670.     def getChildren(self):
  671.         return (self.left, self.right)
  672.  
  673.     
  674.     def getChildNodes(self):
  675.         return (self.left, self.right)
  676.  
  677.     
  678.     def __repr__(self):
  679.         return 'FloorDiv((%s, %s))' % (repr(self.left), repr(self.right))
  680.  
  681.  
  682.  
  683. class For(Node):
  684.     
  685.     def __init__(self, assign, list, body, else_, lineno = None):
  686.         self.assign = assign
  687.         self.list = list
  688.         self.body = body
  689.         self.else_ = else_
  690.         self.lineno = lineno
  691.  
  692.     
  693.     def getChildren(self):
  694.         children = []
  695.         children.append(self.assign)
  696.         children.append(self.list)
  697.         children.append(self.body)
  698.         children.append(self.else_)
  699.         return tuple(children)
  700.  
  701.     
  702.     def getChildNodes(self):
  703.         nodelist = []
  704.         nodelist.append(self.assign)
  705.         nodelist.append(self.list)
  706.         nodelist.append(self.body)
  707.         if self.else_ is not None:
  708.             nodelist.append(self.else_)
  709.         
  710.         return tuple(nodelist)
  711.  
  712.     
  713.     def __repr__(self):
  714.         return 'For(%s, %s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.body), repr(self.else_))
  715.  
  716.  
  717.  
  718. class From(Node):
  719.     
  720.     def __init__(self, modname, names, level, lineno = None):
  721.         self.modname = modname
  722.         self.names = names
  723.         self.level = level
  724.         self.lineno = lineno
  725.  
  726.     
  727.     def getChildren(self):
  728.         return (self.modname, self.names, self.level)
  729.  
  730.     
  731.     def getChildNodes(self):
  732.         return ()
  733.  
  734.     
  735.     def __repr__(self):
  736.         return 'From(%s, %s, %s)' % (repr(self.modname), repr(self.names), repr(self.level))
  737.  
  738.  
  739.  
  740. class Function(Node):
  741.     
  742.     def __init__(self, decorators, name, argnames, defaults, flags, doc, code, lineno = None):
  743.         self.decorators = decorators
  744.         self.name = name
  745.         self.argnames = argnames
  746.         self.defaults = defaults
  747.         self.flags = flags
  748.         self.doc = doc
  749.         self.code = code
  750.         self.lineno = lineno
  751.         self.varargs = None
  752.         self.kwargs = None
  753.         if flags & CO_VARARGS:
  754.             self.varargs = 1
  755.         
  756.         if flags & CO_VARKEYWORDS:
  757.             self.kwargs = 1
  758.         
  759.  
  760.     
  761.     def getChildren(self):
  762.         children = []
  763.         children.append(self.decorators)
  764.         children.append(self.name)
  765.         children.append(self.argnames)
  766.         children.extend(flatten(self.defaults))
  767.         children.append(self.flags)
  768.         children.append(self.doc)
  769.         children.append(self.code)
  770.         return tuple(children)
  771.  
  772.     
  773.     def getChildNodes(self):
  774.         nodelist = []
  775.         if self.decorators is not None:
  776.             nodelist.append(self.decorators)
  777.         
  778.         nodelist.extend(flatten_nodes(self.defaults))
  779.         nodelist.append(self.code)
  780.         return tuple(nodelist)
  781.  
  782.     
  783.     def __repr__(self):
  784.         return 'Function(%s, %s, %s, %s, %s, %s, %s)' % (repr(self.decorators), repr(self.name), repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.doc), repr(self.code))
  785.  
  786.  
  787.  
  788. class GenExpr(Node):
  789.     
  790.     def __init__(self, code, lineno = None):
  791.         self.code = code
  792.         self.lineno = lineno
  793.         self.argnames = [
  794.             '.0']
  795.         self.varargs = None
  796.         self.kwargs = None
  797.  
  798.     
  799.     def getChildren(self):
  800.         return (self.code,)
  801.  
  802.     
  803.     def getChildNodes(self):
  804.         return (self.code,)
  805.  
  806.     
  807.     def __repr__(self):
  808.         return 'GenExpr(%s)' % (repr(self.code),)
  809.  
  810.  
  811.  
  812. class GenExprFor(Node):
  813.     
  814.     def __init__(self, assign, iter, ifs, lineno = None):
  815.         self.assign = assign
  816.         self.iter = iter
  817.         self.ifs = ifs
  818.         self.lineno = lineno
  819.         self.is_outmost = False
  820.  
  821.     
  822.     def getChildren(self):
  823.         children = []
  824.         children.append(self.assign)
  825.         children.append(self.iter)
  826.         children.extend(flatten(self.ifs))
  827.         return tuple(children)
  828.  
  829.     
  830.     def getChildNodes(self):
  831.         nodelist = []
  832.         nodelist.append(self.assign)
  833.         nodelist.append(self.iter)
  834.         nodelist.extend(flatten_nodes(self.ifs))
  835.         return tuple(nodelist)
  836.  
  837.     
  838.     def __repr__(self):
  839.         return 'GenExprFor(%s, %s, %s)' % (repr(self.assign), repr(self.iter), repr(self.ifs))
  840.  
  841.  
  842.  
  843. class GenExprIf(Node):
  844.     
  845.     def __init__(self, test, lineno = None):
  846.         self.test = test
  847.         self.lineno = lineno
  848.  
  849.     
  850.     def getChildren(self):
  851.         return (self.test,)
  852.  
  853.     
  854.     def getChildNodes(self):
  855.         return (self.test,)
  856.  
  857.     
  858.     def __repr__(self):
  859.         return 'GenExprIf(%s)' % (repr(self.test),)
  860.  
  861.  
  862.  
  863. class GenExprInner(Node):
  864.     
  865.     def __init__(self, expr, quals, lineno = None):
  866.         self.expr = expr
  867.         self.quals = quals
  868.         self.lineno = lineno
  869.  
  870.     
  871.     def getChildren(self):
  872.         children = []
  873.         children.append(self.expr)
  874.         children.extend(flatten(self.quals))
  875.         return tuple(children)
  876.  
  877.     
  878.     def getChildNodes(self):
  879.         nodelist = []
  880.         nodelist.append(self.expr)
  881.         nodelist.extend(flatten_nodes(self.quals))
  882.         return tuple(nodelist)
  883.  
  884.     
  885.     def __repr__(self):
  886.         return 'GenExprInner(%s, %s)' % (repr(self.expr), repr(self.quals))
  887.  
  888.  
  889.  
  890. class Getattr(Node):
  891.     
  892.     def __init__(self, expr, attrname, lineno = None):
  893.         self.expr = expr
  894.         self.attrname = attrname
  895.         self.lineno = lineno
  896.  
  897.     
  898.     def getChildren(self):
  899.         return (self.expr, self.attrname)
  900.  
  901.     
  902.     def getChildNodes(self):
  903.         return (self.expr,)
  904.  
  905.     
  906.     def __repr__(self):
  907.         return 'Getattr(%s, %s)' % (repr(self.expr), repr(self.attrname))
  908.  
  909.  
  910.  
  911. class Global(Node):
  912.     
  913.     def __init__(self, names, lineno = None):
  914.         self.names = names
  915.         self.lineno = lineno
  916.  
  917.     
  918.     def getChildren(self):
  919.         return (self.names,)
  920.  
  921.     
  922.     def getChildNodes(self):
  923.         return ()
  924.  
  925.     
  926.     def __repr__(self):
  927.         return 'Global(%s)' % (repr(self.names),)
  928.  
  929.  
  930.  
  931. class If(Node):
  932.     
  933.     def __init__(self, tests, else_, lineno = None):
  934.         self.tests = tests
  935.         self.else_ = else_
  936.         self.lineno = lineno
  937.  
  938.     
  939.     def getChildren(self):
  940.         children = []
  941.         children.extend(flatten(self.tests))
  942.         children.append(self.else_)
  943.         return tuple(children)
  944.  
  945.     
  946.     def getChildNodes(self):
  947.         nodelist = []
  948.         nodelist.extend(flatten_nodes(self.tests))
  949.         if self.else_ is not None:
  950.             nodelist.append(self.else_)
  951.         
  952.         return tuple(nodelist)
  953.  
  954.     
  955.     def __repr__(self):
  956.         return 'If(%s, %s)' % (repr(self.tests), repr(self.else_))
  957.  
  958.  
  959.  
  960. class IfExp(Node):
  961.     
  962.     def __init__(self, test, then, else_, lineno = None):
  963.         self.test = test
  964.         self.then = then
  965.         self.else_ = else_
  966.         self.lineno = lineno
  967.  
  968.     
  969.     def getChildren(self):
  970.         return (self.test, self.then, self.else_)
  971.  
  972.     
  973.     def getChildNodes(self):
  974.         return (self.test, self.then, self.else_)
  975.  
  976.     
  977.     def __repr__(self):
  978.         return 'IfExp(%s, %s, %s)' % (repr(self.test), repr(self.then), repr(self.else_))
  979.  
  980.  
  981.  
  982. class Import(Node):
  983.     
  984.     def __init__(self, names, lineno = None):
  985.         self.names = names
  986.         self.lineno = lineno
  987.  
  988.     
  989.     def getChildren(self):
  990.         return (self.names,)
  991.  
  992.     
  993.     def getChildNodes(self):
  994.         return ()
  995.  
  996.     
  997.     def __repr__(self):
  998.         return 'Import(%s)' % (repr(self.names),)
  999.  
  1000.  
  1001.  
  1002. class Invert(Node):
  1003.     
  1004.     def __init__(self, expr, lineno = None):
  1005.         self.expr = expr
  1006.         self.lineno = lineno
  1007.  
  1008.     
  1009.     def getChildren(self):
  1010.         return (self.expr,)
  1011.  
  1012.     
  1013.     def getChildNodes(self):
  1014.         return (self.expr,)
  1015.  
  1016.     
  1017.     def __repr__(self):
  1018.         return 'Invert(%s)' % (repr(self.expr),)
  1019.  
  1020.  
  1021.  
  1022. class Keyword(Node):
  1023.     
  1024.     def __init__(self, name, expr, lineno = None):
  1025.         self.name = name
  1026.         self.expr = expr
  1027.         self.lineno = lineno
  1028.  
  1029.     
  1030.     def getChildren(self):
  1031.         return (self.name, self.expr)
  1032.  
  1033.     
  1034.     def getChildNodes(self):
  1035.         return (self.expr,)
  1036.  
  1037.     
  1038.     def __repr__(self):
  1039.         return 'Keyword(%s, %s)' % (repr(self.name), repr(self.expr))
  1040.  
  1041.  
  1042.  
  1043. class Lambda(Node):
  1044.     
  1045.     def __init__(self, argnames, defaults, flags, code, lineno = None):
  1046.         self.argnames = argnames
  1047.         self.defaults = defaults
  1048.         self.flags = flags
  1049.         self.code = code
  1050.         self.lineno = lineno
  1051.         self.varargs = None
  1052.         self.kwargs = None
  1053.         if flags & CO_VARARGS:
  1054.             self.varargs = 1
  1055.         
  1056.         if flags & CO_VARKEYWORDS:
  1057.             self.kwargs = 1
  1058.         
  1059.  
  1060.     
  1061.     def getChildren(self):
  1062.         children = []
  1063.         children.append(self.argnames)
  1064.         children.extend(flatten(self.defaults))
  1065.         children.append(self.flags)
  1066.         children.append(self.code)
  1067.         return tuple(children)
  1068.  
  1069.     
  1070.     def getChildNodes(self):
  1071.         nodelist = []
  1072.         nodelist.extend(flatten_nodes(self.defaults))
  1073.         nodelist.append(self.code)
  1074.         return tuple(nodelist)
  1075.  
  1076.     
  1077.     def __repr__(self):
  1078.         return 'Lambda(%s, %s, %s, %s)' % (repr(self.argnames), repr(self.defaults), repr(self.flags), repr(self.code))
  1079.  
  1080.  
  1081.  
  1082. class LeftShift(Node):
  1083.     
  1084.     def __init__(self, .1, lineno = None):
  1085.         (left, right) = .1
  1086.         self.left = left
  1087.         self.right = right
  1088.         self.lineno = lineno
  1089.  
  1090.     
  1091.     def getChildren(self):
  1092.         return (self.left, self.right)
  1093.  
  1094.     
  1095.     def getChildNodes(self):
  1096.         return (self.left, self.right)
  1097.  
  1098.     
  1099.     def __repr__(self):
  1100.         return 'LeftShift((%s, %s))' % (repr(self.left), repr(self.right))
  1101.  
  1102.  
  1103.  
  1104. class List(Node):
  1105.     
  1106.     def __init__(self, nodes, lineno = None):
  1107.         self.nodes = nodes
  1108.         self.lineno = lineno
  1109.  
  1110.     
  1111.     def getChildren(self):
  1112.         return tuple(flatten(self.nodes))
  1113.  
  1114.     
  1115.     def getChildNodes(self):
  1116.         nodelist = []
  1117.         nodelist.extend(flatten_nodes(self.nodes))
  1118.         return tuple(nodelist)
  1119.  
  1120.     
  1121.     def __repr__(self):
  1122.         return 'List(%s)' % (repr(self.nodes),)
  1123.  
  1124.  
  1125.  
  1126. class ListComp(Node):
  1127.     
  1128.     def __init__(self, expr, quals, lineno = None):
  1129.         self.expr = expr
  1130.         self.quals = quals
  1131.         self.lineno = lineno
  1132.  
  1133.     
  1134.     def getChildren(self):
  1135.         children = []
  1136.         children.append(self.expr)
  1137.         children.extend(flatten(self.quals))
  1138.         return tuple(children)
  1139.  
  1140.     
  1141.     def getChildNodes(self):
  1142.         nodelist = []
  1143.         nodelist.append(self.expr)
  1144.         nodelist.extend(flatten_nodes(self.quals))
  1145.         return tuple(nodelist)
  1146.  
  1147.     
  1148.     def __repr__(self):
  1149.         return 'ListComp(%s, %s)' % (repr(self.expr), repr(self.quals))
  1150.  
  1151.  
  1152.  
  1153. class ListCompFor(Node):
  1154.     
  1155.     def __init__(self, assign, list, ifs, lineno = None):
  1156.         self.assign = assign
  1157.         self.list = list
  1158.         self.ifs = ifs
  1159.         self.lineno = lineno
  1160.  
  1161.     
  1162.     def getChildren(self):
  1163.         children = []
  1164.         children.append(self.assign)
  1165.         children.append(self.list)
  1166.         children.extend(flatten(self.ifs))
  1167.         return tuple(children)
  1168.  
  1169.     
  1170.     def getChildNodes(self):
  1171.         nodelist = []
  1172.         nodelist.append(self.assign)
  1173.         nodelist.append(self.list)
  1174.         nodelist.extend(flatten_nodes(self.ifs))
  1175.         return tuple(nodelist)
  1176.  
  1177.     
  1178.     def __repr__(self):
  1179.         return 'ListCompFor(%s, %s, %s)' % (repr(self.assign), repr(self.list), repr(self.ifs))
  1180.  
  1181.  
  1182.  
  1183. class ListCompIf(Node):
  1184.     
  1185.     def __init__(self, test, lineno = None):
  1186.         self.test = test
  1187.         self.lineno = lineno
  1188.  
  1189.     
  1190.     def getChildren(self):
  1191.         return (self.test,)
  1192.  
  1193.     
  1194.     def getChildNodes(self):
  1195.         return (self.test,)
  1196.  
  1197.     
  1198.     def __repr__(self):
  1199.         return 'ListCompIf(%s)' % (repr(self.test),)
  1200.  
  1201.  
  1202.  
  1203. class Mod(Node):
  1204.     
  1205.     def __init__(self, .1, lineno = None):
  1206.         (left, right) = .1
  1207.         self.left = left
  1208.         self.right = right
  1209.         self.lineno = lineno
  1210.  
  1211.     
  1212.     def getChildren(self):
  1213.         return (self.left, self.right)
  1214.  
  1215.     
  1216.     def getChildNodes(self):
  1217.         return (self.left, self.right)
  1218.  
  1219.     
  1220.     def __repr__(self):
  1221.         return 'Mod((%s, %s))' % (repr(self.left), repr(self.right))
  1222.  
  1223.  
  1224.  
  1225. class Module(Node):
  1226.     
  1227.     def __init__(self, doc, node, lineno = None):
  1228.         self.doc = doc
  1229.         self.node = node
  1230.         self.lineno = lineno
  1231.  
  1232.     
  1233.     def getChildren(self):
  1234.         return (self.doc, self.node)
  1235.  
  1236.     
  1237.     def getChildNodes(self):
  1238.         return (self.node,)
  1239.  
  1240.     
  1241.     def __repr__(self):
  1242.         return 'Module(%s, %s)' % (repr(self.doc), repr(self.node))
  1243.  
  1244.  
  1245.  
  1246. class Mul(Node):
  1247.     
  1248.     def __init__(self, .1, lineno = None):
  1249.         (left, right) = .1
  1250.         self.left = left
  1251.         self.right = right
  1252.         self.lineno = lineno
  1253.  
  1254.     
  1255.     def getChildren(self):
  1256.         return (self.left, self.right)
  1257.  
  1258.     
  1259.     def getChildNodes(self):
  1260.         return (self.left, self.right)
  1261.  
  1262.     
  1263.     def __repr__(self):
  1264.         return 'Mul((%s, %s))' % (repr(self.left), repr(self.right))
  1265.  
  1266.  
  1267.  
  1268. class Name(Node):
  1269.     
  1270.     def __init__(self, name, lineno = None):
  1271.         self.name = name
  1272.         self.lineno = lineno
  1273.  
  1274.     
  1275.     def getChildren(self):
  1276.         return (self.name,)
  1277.  
  1278.     
  1279.     def getChildNodes(self):
  1280.         return ()
  1281.  
  1282.     
  1283.     def __repr__(self):
  1284.         return 'Name(%s)' % (repr(self.name),)
  1285.  
  1286.  
  1287.  
  1288. class Not(Node):
  1289.     
  1290.     def __init__(self, expr, lineno = None):
  1291.         self.expr = expr
  1292.         self.lineno = lineno
  1293.  
  1294.     
  1295.     def getChildren(self):
  1296.         return (self.expr,)
  1297.  
  1298.     
  1299.     def getChildNodes(self):
  1300.         return (self.expr,)
  1301.  
  1302.     
  1303.     def __repr__(self):
  1304.         return 'Not(%s)' % (repr(self.expr),)
  1305.  
  1306.  
  1307.  
  1308. class Or(Node):
  1309.     
  1310.     def __init__(self, nodes, lineno = None):
  1311.         self.nodes = nodes
  1312.         self.lineno = lineno
  1313.  
  1314.     
  1315.     def getChildren(self):
  1316.         return tuple(flatten(self.nodes))
  1317.  
  1318.     
  1319.     def getChildNodes(self):
  1320.         nodelist = []
  1321.         nodelist.extend(flatten_nodes(self.nodes))
  1322.         return tuple(nodelist)
  1323.  
  1324.     
  1325.     def __repr__(self):
  1326.         return 'Or(%s)' % (repr(self.nodes),)
  1327.  
  1328.  
  1329.  
  1330. class Pass(Node):
  1331.     
  1332.     def __init__(self, lineno = None):
  1333.         self.lineno = lineno
  1334.  
  1335.     
  1336.     def getChildren(self):
  1337.         return ()
  1338.  
  1339.     
  1340.     def getChildNodes(self):
  1341.         return ()
  1342.  
  1343.     
  1344.     def __repr__(self):
  1345.         return 'Pass()'
  1346.  
  1347.  
  1348.  
  1349. class Power(Node):
  1350.     
  1351.     def __init__(self, .1, lineno = None):
  1352.         (left, right) = .1
  1353.         self.left = left
  1354.         self.right = right
  1355.         self.lineno = lineno
  1356.  
  1357.     
  1358.     def getChildren(self):
  1359.         return (self.left, self.right)
  1360.  
  1361.     
  1362.     def getChildNodes(self):
  1363.         return (self.left, self.right)
  1364.  
  1365.     
  1366.     def __repr__(self):
  1367.         return 'Power((%s, %s))' % (repr(self.left), repr(self.right))
  1368.  
  1369.  
  1370.  
  1371. class Print(Node):
  1372.     
  1373.     def __init__(self, nodes, dest, lineno = None):
  1374.         self.nodes = nodes
  1375.         self.dest = dest
  1376.         self.lineno = lineno
  1377.  
  1378.     
  1379.     def getChildren(self):
  1380.         children = []
  1381.         children.extend(flatten(self.nodes))
  1382.         children.append(self.dest)
  1383.         return tuple(children)
  1384.  
  1385.     
  1386.     def getChildNodes(self):
  1387.         nodelist = []
  1388.         nodelist.extend(flatten_nodes(self.nodes))
  1389.         if self.dest is not None:
  1390.             nodelist.append(self.dest)
  1391.         
  1392.         return tuple(nodelist)
  1393.  
  1394.     
  1395.     def __repr__(self):
  1396.         return 'Print(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1397.  
  1398.  
  1399.  
  1400. class Printnl(Node):
  1401.     
  1402.     def __init__(self, nodes, dest, lineno = None):
  1403.         self.nodes = nodes
  1404.         self.dest = dest
  1405.         self.lineno = lineno
  1406.  
  1407.     
  1408.     def getChildren(self):
  1409.         children = []
  1410.         children.extend(flatten(self.nodes))
  1411.         children.append(self.dest)
  1412.         return tuple(children)
  1413.  
  1414.     
  1415.     def getChildNodes(self):
  1416.         nodelist = []
  1417.         nodelist.extend(flatten_nodes(self.nodes))
  1418.         if self.dest is not None:
  1419.             nodelist.append(self.dest)
  1420.         
  1421.         return tuple(nodelist)
  1422.  
  1423.     
  1424.     def __repr__(self):
  1425.         return 'Printnl(%s, %s)' % (repr(self.nodes), repr(self.dest))
  1426.  
  1427.  
  1428.  
  1429. class Raise(Node):
  1430.     
  1431.     def __init__(self, expr1, expr2, expr3, lineno = None):
  1432.         self.expr1 = expr1
  1433.         self.expr2 = expr2
  1434.         self.expr3 = expr3
  1435.         self.lineno = lineno
  1436.  
  1437.     
  1438.     def getChildren(self):
  1439.         children = []
  1440.         children.append(self.expr1)
  1441.         children.append(self.expr2)
  1442.         children.append(self.expr3)
  1443.         return tuple(children)
  1444.  
  1445.     
  1446.     def getChildNodes(self):
  1447.         nodelist = []
  1448.         if self.expr1 is not None:
  1449.             nodelist.append(self.expr1)
  1450.         
  1451.         if self.expr2 is not None:
  1452.             nodelist.append(self.expr2)
  1453.         
  1454.         if self.expr3 is not None:
  1455.             nodelist.append(self.expr3)
  1456.         
  1457.         return tuple(nodelist)
  1458.  
  1459.     
  1460.     def __repr__(self):
  1461.         return 'Raise(%s, %s, %s)' % (repr(self.expr1), repr(self.expr2), repr(self.expr3))
  1462.  
  1463.  
  1464.  
  1465. class Return(Node):
  1466.     
  1467.     def __init__(self, value, lineno = None):
  1468.         self.value = value
  1469.         self.lineno = lineno
  1470.  
  1471.     
  1472.     def getChildren(self):
  1473.         return (self.value,)
  1474.  
  1475.     
  1476.     def getChildNodes(self):
  1477.         return (self.value,)
  1478.  
  1479.     
  1480.     def __repr__(self):
  1481.         return 'Return(%s)' % (repr(self.value),)
  1482.  
  1483.  
  1484.  
  1485. class RightShift(Node):
  1486.     
  1487.     def __init__(self, .1, lineno = None):
  1488.         (left, right) = .1
  1489.         self.left = left
  1490.         self.right = right
  1491.         self.lineno = lineno
  1492.  
  1493.     
  1494.     def getChildren(self):
  1495.         return (self.left, self.right)
  1496.  
  1497.     
  1498.     def getChildNodes(self):
  1499.         return (self.left, self.right)
  1500.  
  1501.     
  1502.     def __repr__(self):
  1503.         return 'RightShift((%s, %s))' % (repr(self.left), repr(self.right))
  1504.  
  1505.  
  1506.  
  1507. class Slice(Node):
  1508.     
  1509.     def __init__(self, expr, flags, lower, upper, lineno = None):
  1510.         self.expr = expr
  1511.         self.flags = flags
  1512.         self.lower = lower
  1513.         self.upper = upper
  1514.         self.lineno = lineno
  1515.  
  1516.     
  1517.     def getChildren(self):
  1518.         children = []
  1519.         children.append(self.expr)
  1520.         children.append(self.flags)
  1521.         children.append(self.lower)
  1522.         children.append(self.upper)
  1523.         return tuple(children)
  1524.  
  1525.     
  1526.     def getChildNodes(self):
  1527.         nodelist = []
  1528.         nodelist.append(self.expr)
  1529.         if self.lower is not None:
  1530.             nodelist.append(self.lower)
  1531.         
  1532.         if self.upper is not None:
  1533.             nodelist.append(self.upper)
  1534.         
  1535.         return tuple(nodelist)
  1536.  
  1537.     
  1538.     def __repr__(self):
  1539.         return 'Slice(%s, %s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.lower), repr(self.upper))
  1540.  
  1541.  
  1542.  
  1543. class Sliceobj(Node):
  1544.     
  1545.     def __init__(self, nodes, lineno = None):
  1546.         self.nodes = nodes
  1547.         self.lineno = lineno
  1548.  
  1549.     
  1550.     def getChildren(self):
  1551.         return tuple(flatten(self.nodes))
  1552.  
  1553.     
  1554.     def getChildNodes(self):
  1555.         nodelist = []
  1556.         nodelist.extend(flatten_nodes(self.nodes))
  1557.         return tuple(nodelist)
  1558.  
  1559.     
  1560.     def __repr__(self):
  1561.         return 'Sliceobj(%s)' % (repr(self.nodes),)
  1562.  
  1563.  
  1564.  
  1565. class Stmt(Node):
  1566.     
  1567.     def __init__(self, nodes, lineno = None):
  1568.         self.nodes = nodes
  1569.         self.lineno = lineno
  1570.  
  1571.     
  1572.     def getChildren(self):
  1573.         return tuple(flatten(self.nodes))
  1574.  
  1575.     
  1576.     def getChildNodes(self):
  1577.         nodelist = []
  1578.         nodelist.extend(flatten_nodes(self.nodes))
  1579.         return tuple(nodelist)
  1580.  
  1581.     
  1582.     def __repr__(self):
  1583.         return 'Stmt(%s)' % (repr(self.nodes),)
  1584.  
  1585.  
  1586.  
  1587. class Sub(Node):
  1588.     
  1589.     def __init__(self, .1, lineno = None):
  1590.         (left, right) = .1
  1591.         self.left = left
  1592.         self.right = right
  1593.         self.lineno = lineno
  1594.  
  1595.     
  1596.     def getChildren(self):
  1597.         return (self.left, self.right)
  1598.  
  1599.     
  1600.     def getChildNodes(self):
  1601.         return (self.left, self.right)
  1602.  
  1603.     
  1604.     def __repr__(self):
  1605.         return 'Sub((%s, %s))' % (repr(self.left), repr(self.right))
  1606.  
  1607.  
  1608.  
  1609. class Subscript(Node):
  1610.     
  1611.     def __init__(self, expr, flags, subs, lineno = None):
  1612.         self.expr = expr
  1613.         self.flags = flags
  1614.         self.subs = subs
  1615.         self.lineno = lineno
  1616.  
  1617.     
  1618.     def getChildren(self):
  1619.         children = []
  1620.         children.append(self.expr)
  1621.         children.append(self.flags)
  1622.         children.extend(flatten(self.subs))
  1623.         return tuple(children)
  1624.  
  1625.     
  1626.     def getChildNodes(self):
  1627.         nodelist = []
  1628.         nodelist.append(self.expr)
  1629.         nodelist.extend(flatten_nodes(self.subs))
  1630.         return tuple(nodelist)
  1631.  
  1632.     
  1633.     def __repr__(self):
  1634.         return 'Subscript(%s, %s, %s)' % (repr(self.expr), repr(self.flags), repr(self.subs))
  1635.  
  1636.  
  1637.  
  1638. class TryExcept(Node):
  1639.     
  1640.     def __init__(self, body, handlers, else_, lineno = None):
  1641.         self.body = body
  1642.         self.handlers = handlers
  1643.         self.else_ = else_
  1644.         self.lineno = lineno
  1645.  
  1646.     
  1647.     def getChildren(self):
  1648.         children = []
  1649.         children.append(self.body)
  1650.         children.extend(flatten(self.handlers))
  1651.         children.append(self.else_)
  1652.         return tuple(children)
  1653.  
  1654.     
  1655.     def getChildNodes(self):
  1656.         nodelist = []
  1657.         nodelist.append(self.body)
  1658.         nodelist.extend(flatten_nodes(self.handlers))
  1659.         if self.else_ is not None:
  1660.             nodelist.append(self.else_)
  1661.         
  1662.         return tuple(nodelist)
  1663.  
  1664.     
  1665.     def __repr__(self):
  1666.         return 'TryExcept(%s, %s, %s)' % (repr(self.body), repr(self.handlers), repr(self.else_))
  1667.  
  1668.  
  1669.  
  1670. class TryFinally(Node):
  1671.     
  1672.     def __init__(self, body, final, lineno = None):
  1673.         self.body = body
  1674.         self.final = final
  1675.         self.lineno = lineno
  1676.  
  1677.     
  1678.     def getChildren(self):
  1679.         return (self.body, self.final)
  1680.  
  1681.     
  1682.     def getChildNodes(self):
  1683.         return (self.body, self.final)
  1684.  
  1685.     
  1686.     def __repr__(self):
  1687.         return 'TryFinally(%s, %s)' % (repr(self.body), repr(self.final))
  1688.  
  1689.  
  1690.  
  1691. class Tuple(Node):
  1692.     
  1693.     def __init__(self, nodes, lineno = None):
  1694.         self.nodes = nodes
  1695.         self.lineno = lineno
  1696.  
  1697.     
  1698.     def getChildren(self):
  1699.         return tuple(flatten(self.nodes))
  1700.  
  1701.     
  1702.     def getChildNodes(self):
  1703.         nodelist = []
  1704.         nodelist.extend(flatten_nodes(self.nodes))
  1705.         return tuple(nodelist)
  1706.  
  1707.     
  1708.     def __repr__(self):
  1709.         return 'Tuple(%s)' % (repr(self.nodes),)
  1710.  
  1711.  
  1712.  
  1713. class UnaryAdd(Node):
  1714.     
  1715.     def __init__(self, expr, lineno = None):
  1716.         self.expr = expr
  1717.         self.lineno = lineno
  1718.  
  1719.     
  1720.     def getChildren(self):
  1721.         return (self.expr,)
  1722.  
  1723.     
  1724.     def getChildNodes(self):
  1725.         return (self.expr,)
  1726.  
  1727.     
  1728.     def __repr__(self):
  1729.         return 'UnaryAdd(%s)' % (repr(self.expr),)
  1730.  
  1731.  
  1732.  
  1733. class UnarySub(Node):
  1734.     
  1735.     def __init__(self, expr, lineno = None):
  1736.         self.expr = expr
  1737.         self.lineno = lineno
  1738.  
  1739.     
  1740.     def getChildren(self):
  1741.         return (self.expr,)
  1742.  
  1743.     
  1744.     def getChildNodes(self):
  1745.         return (self.expr,)
  1746.  
  1747.     
  1748.     def __repr__(self):
  1749.         return 'UnarySub(%s)' % (repr(self.expr),)
  1750.  
  1751.  
  1752.  
  1753. class While(Node):
  1754.     
  1755.     def __init__(self, test, body, else_, lineno = None):
  1756.         self.test = test
  1757.         self.body = body
  1758.         self.else_ = else_
  1759.         self.lineno = lineno
  1760.  
  1761.     
  1762.     def getChildren(self):
  1763.         children = []
  1764.         children.append(self.test)
  1765.         children.append(self.body)
  1766.         children.append(self.else_)
  1767.         return tuple(children)
  1768.  
  1769.     
  1770.     def getChildNodes(self):
  1771.         nodelist = []
  1772.         nodelist.append(self.test)
  1773.         nodelist.append(self.body)
  1774.         if self.else_ is not None:
  1775.             nodelist.append(self.else_)
  1776.         
  1777.         return tuple(nodelist)
  1778.  
  1779.     
  1780.     def __repr__(self):
  1781.         return 'While(%s, %s, %s)' % (repr(self.test), repr(self.body), repr(self.else_))
  1782.  
  1783.  
  1784.  
  1785. class With(Node):
  1786.     
  1787.     def __init__(self, expr, vars, body, lineno = None):
  1788.         self.expr = expr
  1789.         self.vars = vars
  1790.         self.body = body
  1791.         self.lineno = lineno
  1792.  
  1793.     
  1794.     def getChildren(self):
  1795.         children = []
  1796.         children.append(self.expr)
  1797.         children.append(self.vars)
  1798.         children.append(self.body)
  1799.         return tuple(children)
  1800.  
  1801.     
  1802.     def getChildNodes(self):
  1803.         nodelist = []
  1804.         nodelist.append(self.expr)
  1805.         if self.vars is not None:
  1806.             nodelist.append(self.vars)
  1807.         
  1808.         nodelist.append(self.body)
  1809.         return tuple(nodelist)
  1810.  
  1811.     
  1812.     def __repr__(self):
  1813.         return 'With(%s, %s, %s)' % (repr(self.expr), repr(self.vars), repr(self.body))
  1814.  
  1815.  
  1816.  
  1817. class Yield(Node):
  1818.     
  1819.     def __init__(self, value, lineno = None):
  1820.         self.value = value
  1821.         self.lineno = lineno
  1822.  
  1823.     
  1824.     def getChildren(self):
  1825.         return (self.value,)
  1826.  
  1827.     
  1828.     def getChildNodes(self):
  1829.         return (self.value,)
  1830.  
  1831.     
  1832.     def __repr__(self):
  1833.         return 'Yield(%s)' % (repr(self.value),)
  1834.  
  1835.  
  1836. for name, obj in globals().items():
  1837.     if isinstance(obj, type) and issubclass(obj, Node):
  1838.         nodes[name.lower()] = obj
  1839.         continue
  1840.  
  1841.